/**
 * Created by IntelliJ IDEA.
 * User: Taras_Brzezinsky
 * Date: 8/7/11
 * Time: 3:19 PM
 * To change this template use File | Settings | File Templates.
 */

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.FileReader;
import java.util.StringTokenizer;
import java.io.IOException;
import java.util.Arrays;

public class Cowavans extends Thread {

    public Cowavans() {
        this.input = new BufferedReader(new InputStreamReader(System.in));
        this.output = new PrintWriter(System.out);
        this.setPriority(Thread.MAX_PRIORITY);
    }

    static class Summarizer {
        long[] weights;
        long[] s;
        long can;
        int last = -1;

        public Summarizer(long[] initial) {
            weights = initial.clone();
            s = new long[weights.length];
            can = (int) Math.sqrt(weights.length);
        }

        public long getSum(int a, int b) {
            long result = 0;
            if (b >= can) {
                for (; a < weights.length; a += b) {
                    result += weights[a];
                }
            } else {
                if (b != last) {
                    update(b);
                }
                last = b;
                result = s[a];
            }
            return result;
        }

        private void update(int upper) {
            for (int i = weights.length - 1; i >= 0; --i) {
                s[i] = weights[i];
                if (i + upper < weights.length) {
                    s[i] += s[i + upper];
                }
            }
        }


    }

    static class Query implements Comparable<Query> {
        int a, b, id;

        public Query(int a, int b, int id) {
            this.a = a;
            this.b = b;
            this.id = id;
        }

        public int compareTo(Query o) {
            if (this.b == o.b) {
                if (this.a == o.a) {
                    return this.id - o.id;
                } else {
                    return this.a - o.a;
                }
            } else {
                return this.b - o.b;
            }
        }
    }

    public void run() {
        try {
            int n = nextInt();
            long[] weights = new long[n];
            for (int i = 0; i < n; ++i) {
                weights[i] = nextInt();
            }
            Summarizer process = new Summarizer(weights);
            int q = nextInt();
            Query[] queries = new Query[q];
            for (int i = 0; i < q; ++i) {
                queries[i] = new Query(nextInt() - 1, nextInt(), i);
            }
            Arrays.sort(queries);
            long []ans = new long [q];
            for (Query current : queries) {
                ans[current.id] = process.getSum(current.a, current.b);
            }
            for (long current : ans) {
                output.println(current);
            }
            output.flush();
            output.close();

        } catch (Throwable e) {
            System.err.println(e.getMessage());
            System.err.println(Arrays.deepToString(e.getStackTrace()));
        }
    }


    public static void main(String[] args) {
        new Cowavans().start();
    }

    private String nextToken() throws IOException {
        while (tokens == null || !tokens.hasMoreTokens()) {
            tokens = new StringTokenizer(input.readLine());
        }
        return tokens.nextToken();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }


    private BufferedReader input;
    private PrintWriter output;
    private StringTokenizer tokens = null;
}
